package com.softer.chengxin.person.service.impl;

import com.softer.chengxin.common.domin.*;
import com.softer.chengxin.common.enums.ResultEnum;
import com.softer.chengxin.corp.dao.CorpDao;
import com.softer.chengxin.corp.service.impl.CorpServiceImpl;
import com.softer.chengxin.person.dao.PersonDao;
import com.softer.chengxin.person.domin.Person;
import com.softer.chengxin.person.service.PersonService;
import com.softer.chengxin.project.dao.ProjectDao;
import com.softer.chengxin.score.entity.ScoreRecord;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;

/**
 * @author Gong Zhiyang
 * @date 2018/9/27
 */
@Service
public class PersonServiceImpl implements PersonService {
    private Logger logger = LoggerFactory.getLogger(PersonServiceImpl.class);
    @Autowired
    private PersonDao personDao;
    @Autowired
    private ProjectDao projectDao;
    @Autowired
    private CorpServiceImpl corpService;

    /**
     * 查询企业主要人员
     *
     * @param id   企业ID
     * @param duty 职务
     * @return 人员信息
     */
    @Override
    public Person queryMainPersonnel(Integer id, String duty) {
        Person person = personDao.queryMainPersonnel(id, duty);
        if (person != null) {
            return person;
        }
        return new Person();
    }

    /**
     * 物业人员信息添加
     *
     * @param person 人员实体
     * @return 结果集
     */
    @Override
    public synchronized CommonResult addPerson(Person person) {
        try {
            //校验职务
            String duty = person.getDuties();
            if (StringUtils.isBlank(duty)) {
                return new CommonResult(ResultEnum.FAIL.getCode(), "请选择职务");
            }
            if (Common.ONE.equals(duty) || Common.TWO.equals(duty)
                    || String.valueOf(Common.THREE).equals(duty)
                    || String.valueOf(Common.FOUR).equals(duty)) {
                //如果增加的是主要人员,先判断是否添加过
                Person mainPerson = personDao.queryMainPersonnel(Integer.parseInt(person.getCompanyId()), person.getDuties());
                if (mainPerson != null) {
                    return new CommonResult(ResultEnum.FAIL.getCode(), "该职务已经添加，请确认后添加");
                }
            }
            //校验身份证
            CommonResult commonResult = checkIdCard(person);
            if (ResultEnum.FAIL.getCode() == commonResult.getData()) {
                return new CommonResult(ResultEnum.FAIL.getCode(), commonResult.getMessage());
            }
            int num = personDao.addPerson(person);
            if (num == Integer.parseInt(Common.ONE)) {
                //新增人员成功后
//                //重新算分
//                corpService.updateRecord(Integer.parseInt(person.getCompanyId()));
                return new CommonResult(ResultEnum.SUCCESS.getCode(), "人员基本信息保存成功！");
            }
        } catch (Exception e) {
            logger.error("新增人员基本信息失败", e);
        }
        return new CommonResult(ResultEnum.FAIL.getCode(), "人员基本信息保存失败，请稍后再试！");
    }

    /**
     * 校验身份证
     *
     * @param person 人员信息
     * @return 结果
     */
    private CommonResult checkIdCard(Person person) {
        //身份证
        String idCard = person.getIdCard();
        if (StringUtils.isNotBlank(idCard)) {
            //判断数据库中是否存在该身份证
            String card = personDao.selectPerson(idCard);
            if (StringUtils.isNotBlank(card)) {
                //判断当前企业是否存在该身份证
                String corpPerson = personDao.checkCorpPerson(idCard, person.getCompanyId());
                if (StringUtils.isNotBlank(corpPerson)) {
                    //判断该身份证的职务，如果是法人代表/总经理/财务负责人/工程负责人，
                    // 同时添加的职务是总经理/法人代表/财务负责人/工程负责人，则允许添加，否则不允许添加
                    /*String duty = personDao.checkDuty(idCard);
                    if (Common.ONE.equals(duty) || Common.TWO.equals(duty) || String.valueOf(Common.THREE).equals(duty) || String.valueOf(Common.FOUR).equals(duty)) {
                        if (!Common.ONE.equals(person.getDuties()) && !Common.TWO.equals(person.getDuties()) && !String.valueOf(Common.THREE).equals(person.getDuties()) && !String.valueOf(Common.FOUR).equals(person.getDuties())) {
                            return new CommonResult(ResultEnum.FAIL.getCode(), "该身份证已注册其他职业");
                        }
                    } else {
                        return new CommonResult(ResultEnum.FAIL.getCode(), "该身份证已注册其他职业");
                    }*/
                } else {
                    return new CommonResult(ResultEnum.FAIL.getCode(), "身份证信息已经注册，请核实后添加");
                }
            }
        } else {
            return new CommonResult(ResultEnum.FAIL.getCode(), "请填写身份证号码");
        }
        return new CommonResult(ResultEnum.SUCCESS.getCode(), "校验成功");
    }

    /**
     * 物业人员信息编辑
     *
     * @param person 人员实体
     * @return 处理结果
     */
    @Override
    public CommonResult updatePerson(Person person) {
        try {
            CommonResult commonResult = checkPerson(person);
            if (ResultEnum.FAIL.getCode() == commonResult.getData()) {
                return new CommonResult(ResultEnum.FAIL.getCode(), commonResult.getMessage());
            }
            int ret = personDao.updatePerson(person);
            if (ret == Integer.parseInt(Common.ONE)) {
                return new CommonResult(ResultEnum.SUCCESS.getCode(), "人员基本信息修改成功！");
            }
        } catch (Exception e) {
            logger.error("修改人员基本信息失败", e);
        }
        return new CommonResult(ResultEnum.FAIL.getCode(), "人员基本信息修改失败，请稍后再试！");
    }

    /**
     * 修改人员时，判断人员信息
     *
     * @param person 人员信息
     * @return 校验结果
     */
    private CommonResult checkPerson(Person person) {
        Person personById = personDao.queryPersonById(person.getId());
        //如果修改人员时，身份证有修改的话
        if (!person.getIdCard().equals(personById.getIdCard())) {
            return checkIdCard(person);
        }
        return new CommonResult(ResultEnum.SUCCESS.getCode(), "校验成功");
    }

    /**
     * 分页查询企业人员列表
     *
     * @param page         页面信息
     * @param id           企业ID
     * @param name         人员名字
     * @param departmentId 部门ID
     * @return 人员列表
     */
    @Override
    public ManagerPageResult queryPersonList(Page page, Integer id, String name, Integer departmentId) {
        ManagerPageResult mr = new ManagerPageResult();
        JsonResult jr = new JsonResult();
        try {
            //查询企业从业人员信息数量
            int num = personDao.queryPersonListNum(id, name, departmentId);
            if (num > Integer.parseInt(Common.ZERO)) {
                //分页查询企业人员列表
                List<Person> personList = personDao.queryPersonList(page, id, name, departmentId);
                setResult(mr, jr, num, personList);
                return mr;
            }
        } catch (Exception e) {
            logger.error("分页查询企业人员列表失败", e);
        }
        setResult(mr, jr, Integer.parseInt(Common.ZERO), new ArrayList());
        return mr;
    }

    /**
     * 根据人员Id查询人员详情
     *
     * @param id 人员Id
     * @return 人员详情
     */
    @Override
    public Person queryPersonById(Integer id) {
        try {
            return personDao.queryPersonById(id);
        } catch (Exception e) {
            logger.error("根据人员Id查询人员详情失败", e);
        }
        return new Person();
    }

    /**
     * 刪除人员（将人员状态设为离职,离职状态设置为10）
     *
     * @param id   人员Id
     * @param type 删除类型（0离职，1从项目中删除）
     * @return 处理结果
     */
    @Override
    public CommonResult delete(Integer id, Integer type) {
        int num = Integer.parseInt(Common.ZERO);
        try {
            if (Integer.parseInt(Common.ZERO) == type) {
                //离职
                num = personDao.delete(id);
            } else if (Integer.parseInt(Common.ONE) == type) {
                //删除项目人员
                num = personDao.updatePersonProject(id);
            }
            if (num == Integer.parseInt(Common.ONE)) {
                return new CommonResult(ResultEnum.SUCCESS.getCode(), "删除成功");
            }
        } catch (Exception e) {
            logger.error("刪除人员失败", e);
        }
        return new CommonResult(ResultEnum.FAIL.getCode(), "删除失败，请稍后重试");
    }

    /**
     * 查询企业所有人员，用于下拉列表
     *
     * @param name 姓名，用于模糊查询
     * @param id   企业ID
     * @return 人员列表
     */
    @Override
    public List<Person> queryAllPerson(String name, Integer id) {
        return personDao.queryAllPerson(name, id);
    }

    /**
     * 查询项目人员列表
     *
     * @param projectId 项目Id
     * @param page      页面实体
     * @param person    查询实体
     * @return 人员列表
     */
    @Override
    public ManagerPageResult queryProjectPersonList(Page page, String projectId, Person person) {
        ManagerPageResult mr = new ManagerPageResult();
        JsonResult jr = new JsonResult();
        try {
            //根据前端创建的projectId查询项目的ID
            Integer id = projectDao.getProjectId(projectId);
            if (id == null) {
                setResult(mr, jr, Integer.parseInt(Common.ZERO), new ArrayList());
                return mr;
            }
            person.setProjectId(String.valueOf(id));
            //查询项目人员数量
            int num = personDao.queryProjectPersonNum(person);
            if (num > Integer.parseInt(Common.ZERO)) {
                List<Person> list = personDao.queryProjectPersonList(page, person);
                setResult(mr, jr, num, list);
                return mr;
            }
        } catch (Exception e) {
            logger.error("查询项目人员列表失败", e);
        }
        setResult(mr, jr, Integer.parseInt(Common.ZERO), new ArrayList());
        return mr;
    }

    /**
     * 增加项目人员
     *
     * @param person    人员实体
     * @param projectId 项目ID（前端创建的ID）
     * @return 添加结果
     */
    @Override
    public CommonResult addProjectPerson(Person person, String projectId) {
        try {
            //根据前端创建的projectId查询项目的ID
            Integer id = projectDao.getProjectId(projectId);
            if (id == null) {
                return new CommonResult(ResultEnum.FAIL.getCode(), "项目还未创建,请先创建项目信息");
            }
            if (StringUtils.isBlank(person.getIdCard())) {
                return new CommonResult(ResultEnum.FAIL.getCode(), "请填写身份证");
            }
            person.setProjectId(String.valueOf(id));
            int num = 0;
            //校验身份证
            Person personByIdCard = personDao.getPersonByIdCard(person.getIdCard());
            if (personByIdCard != null) {
                if (person.getCompanyId().equals(personByIdCard.getCompanyId())) {
                    if (!Common.ZERO.equals(personByIdCard.getProjectId())) {
                        return new CommonResult(ResultEnum.FAIL.getCode(), "该人员为其他项目人员");
                    } else {
                        // 将从业人员改为项目人员
                        person.setId(personByIdCard.getId());
                        num = personDao.updateProjectPerson(person);
                    }
                } else {
                    return new CommonResult(ResultEnum.FAIL.getCode(), "该人员为其他企业人员");
                }
            } else {
                num = personDao.addPerson(person);
            }
            if (num == Integer.parseInt(Common.ONE)) {
                //新增人员成功后
//                //重新算分
//                corpService.updateRecord(Integer.parseInt(person.getCompanyId()));
                return new CommonResult(ResultEnum.SUCCESS.getCode(), "项目人员基本信息保存成功！");
            }
        } catch (Exception e) {
            logger.error("增加项目人员失败", e);
        }
        return new CommonResult(ResultEnum.FAIL.getCode(), "项目人员基本信息保存失败，请稍后再试！");
    }

    /**
     * 删除从业人员
     *
     * @param id 人员ID
     * @return 处理结果
     */
    @Override
    public CommonResult deletePerson(Integer id) {
        try {
            int num = personDao.deletePerson(id);
            if (num == Integer.parseInt(Common.ONE)) {
                return new CommonResult(ResultEnum.SUCCESS.getCode(), "删除成功");
            }
        } catch (Exception e) {
            logger.error("删除从业人员错误", e);
        }
        return new CommonResult(ResultEnum.FAIL.getCode(), "删除失败，请稍后重试");
    }

    /**
     * 根据身份证验证人员
     *
     * @param idCard 身份证
     */
    private CommonResult checkIdCard(String idCard, String companyId) {
        Person person = personDao.getPersonByIdCard(idCard);
        if (person != null) {
            if (companyId.equals(person.getCompanyId())) {

            } else {
                return new CommonResult(ResultEnum.FAIL.getCode(), "该人员为其他企业人员");
            }
        }
        return new CommonResult(ResultEnum.SUCCESS.getCode(), "验证成功");
    }

    /**
     * 设置返回参数
     *
     * @param mpr  ManagerPageResult
     * @param jr   JsonResult
     * @param num  数量
     * @param list 集合列表
     */
    private void setResult(ManagerPageResult mpr, JsonResult jr, int num, List list) {
        mpr.setCount(num);
        jr.setDs(list);
        mpr.setJson(jr);
    }
}
